ME.c

Go to the documentation of this file.

#include "derivative.h"
#include "Compile_Options.h"
#include "ME.h"
/*
 ******************************************************************************
 * Constants
 ******************************************************************************
 */
static const uint32_t cu32EnabledModes = 
  (STOP0_DISABLED | HALT0_DISABLED | RUN3_ENABLED | RUN2_ENABLED | \
   RUN1_ENABLED   | TEST_DISABLED);
static const uint32_t cau32RunModeConfig[] = 
{
  /* RUN 0 - External Clock (40 MHz on demo board) */
  (PDO_OFF  | MVRON_ON  | DATA_FLASH_ON  | CODE_FLASH_ON  | PLL1_OFF | \
   PLL0_OFF | XOSC0_ON  | IRC_16MHZ_OFF  | SYSCLK_IS_XOSC), 
  
  /* RUN 1 - Internal Clock */
  (PDO_OFF  | MVRON_ON  | DATA_FLASH_ON  | CODE_FLASH_ON  | PLL1_OFF | \
   PLL0_OFF | XOSC0_OFF | IRC_16MHZ_ON   | SYSCLK_IS_IRC), 
  
  /* RUN 2 - XOSC without IRC on for CLKOUT */
  (PDO_OFF  | MVRON_ON  | DATA_FLASH_ON  | CODE_FLASH_ON | PLL1_OFF | \
   PLL0_ON  | XOSC0_ON  | IRC_16MHZ_ON   | SYSCLK_IS_XOSC), 
  
  /* RUN 3 - PLL with PLL1 on for CLKOUT */
  (PDO_OFF  | MVRON_ON  | DATA_FLASH_ON  | CODE_FLASH_ON | PLL1_ON  | \
   PLL0_ON  | XOSC0_ON  | IRC_16MHZ_OFF   | SYSCLK_IS_PLL0), 
};
static const uint32_t cu32Halt0ModeConfig = 
  /* HALT 0 */
  (PDO_OFF  | MVRON_OFF | DATA_FLASH_LP  | CODE_FLASH_LP  | PLL1_OFF | \
   PLL0_OFF | XOSC0_OFF | IRC_16MHZ_ON   | SYSCLK_IS_IRC);
/* Contains STOP mode configuration */
static const uint32_t cu32Stop0ModeConfig = 
  /* STOP 0 */
  (PDO_OFF  | MVRON_OFF | DATA_FLASH_OFF | CODE_FLASH_OFF | PLL1_OFF | \
   PLL0_OFF | XOSC0_OFF | IRC_16MHZ_OFF   | SYSCLK_IS_OFF);
/*
 ******************************************************************************
 * u8fnInitDefaultPeripheralPresets
 ******************************************************************************
 */
uint8_t u8fnInitDefaultPeripheralPresets(void)
{
  /* Declare local variables */
  uint8_t u8Status;
  
  /* Init Local variables */
  u8Status =  CLEAR;
  
  /* Verify that we are not in the middle of a transition before configuring */
  if((CLEAR == ME_TRANSITION) && (TRUE == ME_REGULATOR_READY))
  {
    /* Load default configuration where peripherals are always on */
    ME.RUNPC[PERIPH_ALWAYS_ON].B.RUN3 = TRUE;
    ME.RUNPC[PERIPH_ALWAYS_ON].B.RUN2 = TRUE;
    ME.RUNPC[PERIPH_ALWAYS_ON].B.RUN1 = TRUE;
    ME.RUNPC[PERIPH_ALWAYS_ON].B.RUN0 = TRUE;
    ME.RUNPC[PERIPH_ALWAYS_ON].B.DRUN = TRUE;
    ME.RUNPC[PERIPH_ALWAYS_ON].B.SAFE = CLEAR;
    ME.RUNPC[PERIPH_ALWAYS_ON].B.TEST = CLEAR;
    
    ME.LPPC[PERIPH_ALWAYS_ON].B.STANDBY0 = TRUE;
    ME.LPPC[PERIPH_ALWAYS_ON].B.STOP0    = TRUE;
    ME.LPPC[PERIPH_ALWAYS_ON].B.HALT0    = TRUE;
    
    /* Load default configuration where peripherals are always off */
    ME.RUNPC[PERIPH_ALWAYS_OFF].B.RUN3 = CLEAR;
    ME.RUNPC[PERIPH_ALWAYS_OFF].B.RUN2 = CLEAR;
    ME.RUNPC[PERIPH_ALWAYS_OFF].B.RUN1 = CLEAR;
    ME.RUNPC[PERIPH_ALWAYS_OFF].B.RUN0 = CLEAR;
    ME.RUNPC[PERIPH_ALWAYS_OFF].B.DRUN = CLEAR;
    ME.RUNPC[PERIPH_ALWAYS_OFF].B.SAFE = CLEAR;
    ME.RUNPC[PERIPH_ALWAYS_OFF].B.TEST = CLEAR;
    
    ME.LPPC[PERIPH_ALWAYS_ON].B.STANDBY0 = CLEAR;
    ME.LPPC[PERIPH_ALWAYS_ON].B.STOP0    = CLEAR;
    ME.LPPC[PERIPH_ALWAYS_ON].B.HALT0    = CLEAR;
  }
  else
  {
    /* Flag as an error */
    u8Status = ME_HW_NOT_READY;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnConfigPeripheralForMCUModePreset
 ******************************************************************************
 */
uint8_t u8fnConfigPeripheralForMCUModePreset(const uint8_t u8PeripheralIndex, \
                                             const uint8_t u8ConfigurationIndex)
{
  /* Declare local variables */
  uint8_t u8Status;
  
  /* Init local variables */
  u8Status = CLEAR;
  
  /* Verify that the passed values are within the possibilities of HW */
  if((MAX_PERIPH_INDEX_POSSIBLE > u8PeripheralIndex) && \
     (MAX_PERIPH_CONFIG_POSSIBLE > u8ConfigurationIndex))
  {
    /* If so, set the peripheric to the interrupt */
    ME.PCTL[u8PeripheralIndex].R = u8ConfigurationIndex;
  }
  else
  {
    /* Else, flag as error */
    u8Status = ME_INVALID_INDEX;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnCurrentOperationMode
 ******************************************************************************
 */
uint8_t u8fnCurrentOperationMode(void)
{
  return((uint8_t)ME.GS.B.S_CURRENTMODE);
}
/*
 ******************************************************************************
 * u8fnInitDefaultOpModes
 ******************************************************************************
 */
uint8_t u8fnInitDefaultOpModes(void)
{
  /* Declare local variables */
  uint8_t u8Status;
  uint8_t u8Counter;
  
  /* Init local variables */
  u8Status =  CLEAR;
  u8Counter = CLEAR;
  
  /* Verify that we are not in the middle of a transition before configuring */
  /* Verify that we are in RUND since we can only configure in this mode     */
  if((CLEAR == ME_TRANSITION) && (TRUE == ME_REGULATOR_READY))
  {
    if(DRUN_MODE == u8fnCurrentOperationMode())
    {
      for (u8Counter = (sizeof(cau32RunModeConfig) / BYTES_IN_32); \
           u8Counter > CLEAR; u8Counter--)
      {
        ME.RUN[u8Counter - 1u].R = cau32RunModeConfig[u8Counter - 1u];
      }
    
      ME.HALT0.R = cu32Halt0ModeConfig;
      ME.STOP0.R = cu32Stop0ModeConfig;
      
      /* Enable modes as stipulated through the constant variable */
      ME.MER.R = cu32EnabledModes;
    }
    else
    {
      /* Mode was not DRUN - we cannot change behaviors */
      u8Status = ME_INVALID_RUN_MODE;
    }
  }
  else
  {
    /* Flag error */
    u8Status = ME_HW_NOT_READY;
  }
  
  return(u8Status);
}
/*
 ******************************************************************************
 * u8fnInitDefaultOpModes
 ******************************************************************************
 */
uint8_t u8fnSwitchOpModes(const uint8_t u8Mode)
{
  /* Declare local variables */
  uint8_t u8Status;
  uint16_t u16Counter;
  
  u16Counter = CLEAR;
  u8Status   = ME_OP_MODE_CHANGE_DIDNT_OCCUR;
  
  /* Switching modes is performed by a two-step operation */
  /* 1) ME_MCTL must be written with a special key and the desired mode */
  ME.MCTL.R = (uint32_t)((u8Mode << 28u) | CHANGE_MODE_KEY_1);
  /* 2) ME_MCTL must be written with a second key and the desired mode */
  ME.MCTL.R = (uint32_t)((u8Mode << 28u) | CHANGE_MODE_KEY_2);
  
  /* Wait for the operation to take */
  do
  {
    /* If hardware states that we are done with the transition */
    if(CLEAR == ME.GS.B.S_MTRANS)
    {
      /* Verify that we have changed operation mode to what we have asked */
      if(u8Mode == u8fnCurrentOperationMode())
      {
        u8Status = CLEAR;
      }
      else
      {
        /* Nothing */
      }
    }
    else
    {
      /* loop */
    }
  }while((u16Counter++ < SWITCH_MODE_TIMEOUT) & 
         (u8Status == ME_OP_MODE_CHANGE_DIDNT_OCCUR));

  return(u8Status);
}
/*
 ******************************************************************************
 *
 *  End of file.
 *
 ******************************************************************************
 */